// -----------------------------------------------
// Template GA: frmModifica.cs	rel: 3.0.1.0 NoDal
// -----------------------------------------------
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using IGCal.Windows.ReaderControls;
using IGCal.GA;
using IGCal.Funzioni;
using IGCal.DB;
using IGCal.Windows.DB;
using IGCal.GA.BaseObjects;
using System.Data;

namespace Calcio.DefaultDirigenti
{
	/// <summary>
	/// Form di modifica 'frmDefaultDirigentiModifica'
	/// </summary>
	public partial class frmDefaultDirigentiModifica : frmModificaBase
	{
	
		// ********** Per la security ************
        // private const string _PermissionName = "PermissionName"; // Sostituire con il nome della funzionalità
        // ***************************************
		
		/// <summary>
		/// Costruttore
		/// </summary>
		public frmDefaultDirigentiModifica()
		{
			// This call is required by the Windows Form Designer.
			InitializeComponent();
		}

		// ********** Per la security ************
        //protected override void OnLoad(EventArgs e)
        //{
        //    base.OnLoad(e);

        //    //Serve per abilitare le label in partenza
        //    IGCal.Windows.Security.Application.SetLabelVisible(this);
		//    #warning aggiungere al form un controllo di tipo IGCal.Windows.Security.ControlSecurity
        //    //Applica le abilitazioni a tutti i controlli del form
        //    IGCal.Windows.Security.Application.SetSecurityFunction(this, controlSecurity, _PermissionName);
        //}
        // ***************************************
		
		
		#region Gestione lancio form con singola istanza

		static frmDefaultDirigentiModifica _this;

		/// <summary>
		/// Si occupa di far partire il form in singola istanza
		/// </summary>
		public static void StartSingleInstance()
		{
			StartSingleInstance(null);
		}

		/// <summary>
		/// Si occupa di far partire il form in singola istanza
		/// </summary>
		/// <param name="fkControl">FK da cui  stata chiamata la form</param>
		public static void StartSingleInstance(fkDefaultDirigenti fkControl)
		{

			if ((_this != null) && (_this.Visible = true))
			{
				// Se il form  gi caricato e visibile lo porto in primo piano
				_this.BringToFront();
				return;
			}

			// Se il form non esiste oppure esiste ma  non visibile distruggo l'istanza precedente e visualizzo una nuova istanza
			_this = null;

			_this = new frmDefaultDirigentiModifica();

			_this.Closed += new System.EventHandler(OnFormsClosed);

			_this.Start(fkControl);
		}

		/// <summary>
		/// Chiusura del form
		/// </summary>
		/// <param name="sender">Oggetto inviante l'evento</param>
		/// <param name="e">Argomenti standard dell'evento</param>
		protected static void OnFormsClosed(object sender, System.EventArgs e)
		{
			_this = null;
		}

		#endregion

		#region FUNZIONI E METODI

		private void Initialize()
		{
			// Legame delle procedure agli eventi
			LegaProcedureAEventi();

			fkIDDirigente.FiltroAnno = Settings.ProjectSettings.AnnoCorrente;
	
			// ****************************************************************************************
			// DETAILS
			// dtlXXX.Initialize(this);
			// ****************************************************************************************
		}

		/// <summary>
		/// Si occupa di far partire il form
		/// </summary>
		public void Start()
		{
			Start(null, DBNull.Value, DBNull.Value, DBNull.Value);
		}

		/// <summary>
		/// Si occupa di far partire il form
		/// </summary>
		/// <param name="fkControl">Controllo fk chiamante</param>
		public void Start(fkDefaultDirigenti fkControl)
		{
			Start(fkControl, DBNull.Value, DBNull.Value, DBNull.Value);
		}

		/// <summary>
		/// Si occupa di far partire il form
		/// </summary>
		/// <param name="ID">Valori dei campi componenti la chiave dell'elemento da cui  stata effettuata la chiamata</param>
		public void Start(object IDDirigente, object IDRuoloDirigenteInGara, object Casa)
		{
			Start(null, IDDirigente, IDRuoloDirigenteInGara, Casa);
		}

		/// <summary>
		/// Si occupa di far partire il form
		/// </summary>
		/// <param name="fkControl">Controllo fk chiamante</param>
		/// <param name="ID">Valori dei campi componenti la chiave dell'elemento da cui  stata effettuata la chiamata</param>
		public void Start(fkDefaultDirigenti fkControl, object IDDirigente, object IDRuoloDirigenteInGara, object Casa)
		{
			this.MdiParent = Globals.MDIForm;

			base.Start(ctlRicerca, Globals.MDIForm, Globals.Connection);
			Initialize();

			// Altrimenti potrebbero essere abilitati dal codice di inizializzazione dei campi presenti nella region
			Buttons.GestioneTasti(ButtonsKeyPressed.New);

			_fkControl = fkControl;
			this.Show();

			if (IDDirigente != DBNull.Value && IDRuoloDirigenteInGara != DBNull.Value && Casa != DBNull.Value)
			{
				// Se si desidera anche fare caricare in lista l'elemento il cui ID  stato passato come parametro
				if (ctlRicerca.AggiungiSeEsiste((int)IDDirigente, (int)IDRuoloDirigenteInGara, General.DBToBool(Casa)))
					RecordAVideo((int)IDDirigente, (int)IDRuoloDirigenteInGara, General.DBToBool(Casa));
			}
			else
			{
				btnNuovo();
			}

			this.BringToFront();
		}

		/// <summary>
		/// Pulisce i campi a video 
		/// </summary>
		protected virtual void PulisciCampi()
		{
			// Pulisco gli errorProvider
			PulisciErrorProvider();

			fkIDDirigente.ID = DBNull.Value;
			fkIDRuoloDirigenteInGara.ID = DBNull.Value;
			chkCasa.CheckState = CheckState.Unchecked;
 
			// Ripristino i defalut dei campi
			base.RipristinoCriteri(Globals.ConfigurableSettingsSerializer);

			// **************************************************************************************
			// Inserire in questo punto le eventuali forzature dei defalut definiti dal programmatore
			// **************************************************************************************
		}

		/// <summary>
		/// Riporta i valori dei campi dal DB a video
		/// </summary>
		/// <param name="row">Record da scrivere a video</param>
		protected virtual void CampiAVideo(System.Data.DataRow row)
		{
			// Pulisco gli errorProvider
			PulisciErrorProvider();

			fkIDDirigente.ID = row["IDDirigente"];
			fkIDRuoloDirigenteInGara.ID = row["IDRuoloDirigenteInGara"];
			chkCasa.Checked = General.DBToBool(row["Casa"]);
		}

		/// <summary>
		/// Riporta i valori compilati a video sul DB
		/// </summary>
		/// <param name="row">Record su cui aggiornare i campi a video</param>
		protected virtual void CampiSuDB(System.Data.DataRow row)
		{
			// row["DataModifica"] = Globals.Connection.SQLNow();
			// row["UtenteModifica"] = IGCal.Security.Application.User;

		}

		/// <summary>
		/// Recupera il record cercato
		/// </summary>
		/// <param name="ID">Elenco dei valori campi sui quali effettuare la ricerca</param>
		/// <returns>DataTable contenente il record recuperato</returns>
		protected System.Data.DataTable RecuperaRecord(int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			return RecuperaRecord(IDDirigente, IDRuoloDirigenteInGara, Casa, DA);
		}

		/// <summary>
		/// Recupera il record cercato
		/// </summary>
		/// <param name="ID">Elenco dei valori campi sui quali effettuare la ricerca</param>
		/// <param name="DataAdapter">DataAdapter</param>
		/// <returns>DataTable contenente il record recuperato</returns>
		protected System.Data.DataTable RecuperaRecord(int IDDirigente, int IDRuoloDirigenteInGara, bool Casa, DataAdapter DataAdapter)
		{
			string SQL = string.Empty;

			SQL += "Select ";
			SQL += "    * ";
			SQL += "From ";
			SQL += "    DefaultDirigenti ";
			SQL += "Where ";
			SQL += "    DefaultDirigenti.IDDirigente = " + string.Format("{0:0}", IDDirigente) + " And ";
			SQL += "    DefaultDirigenti.IDRuoloDirigenteInGara = " + string.Format("{0:0}", IDRuoloDirigenteInGara) + " And ";

			if (Casa)
				SQL += "    DefaultDirigenti.Casa is NOT null and DefaultDirigenti.Casa <> 0 And ";
			else
				SQL += "    (DefaultDirigenti.Casa is null or DefaultDirigenti.Casa = 0) And ";
		

			return Globals.Connection.GetDataTable(DataAdapter, SQL.Remove(SQL.Length - 5, 5));
		}

		/// <summary>
		/// Inizializza l'oggetto usato per evidenziare i campi obbligatori
		/// </summary>
		protected virtual void PulisciErrorProvider()
		{
			errorProvider.SetError(fkIDDirigente, "");
			errorProvider.SetError(fkIDRuoloDirigenteInGara, "");
		}

		/// <summary>
		/// Effettua il controllo che tutti i campi definiti come obbligatori siano stati valorizzati
		/// </summary>
		/// <returns>true se sono tutti compilati, altrimenti false</returns>
		protected virtual bool ControllaCampi()
		{
			return ControllaCampi(null);
		}

		/// <summary>
		/// Effettua il controllo che tutti i campi definiti come obbligatori siano stati valorizzati
		/// </summary>
		/// <param name="controllo">Oggetto su cui effettuare il controllo</param>
		/// <returns>true se sono tutti compilati, altrimenti false</returns>
		protected virtual bool ControllaCampi(System.Windows.Forms.Control controllo)
		{
			Control ControlloPerFocus = null;
			bool FattoFocus = false;
			bool ValoreRitornoFunzione = true;
			string Campi = string.Empty;
			string Descrizione = string.Empty;
			string Stato = string.Empty;

			// Pulisco gli errorProvider
			if (controllo == null)
				PulisciErrorProvider();

			// Controllo lo stato del controllo fkIDDirigente
			if (controllo == fkIDDirigente | controllo == null)
			{
				if (fkIDDirigente.ID == DBNull.Value)
				{
					ValoreRitornoFunzione = false;
					errorProvider.SetError(fkIDDirigente, "Inserire un valore per dirigente.");
					errorProvider.SetIconAlignment(fkIDDirigente, ErrorIconAlignment.TopLeft);

					// Compongo le stringhe per la form dei campi obbligatori
					Campi += "Dirigente|";
					Descrizione += errorProvider.GetError(fkIDDirigente).ToString() + "|";
					Stato += "Attenzione|";

					if (!FattoFocus & controllo == null)
					{
						ControlloPerFocus = fkIDDirigente;
						FattoFocus = true;
					}
					else if (controllo != null)
					{
						return ValoreRitornoFunzione;
					}
				}
				else
				{
					errorProvider.SetError(fkIDDirigente, "");
				}
			}

			// Controllo lo stato del controllo numIDRuoloDirigenteInGara
			if (controllo == fkIDRuoloDirigenteInGara | controllo == null)
			{
				if (fkIDRuoloDirigenteInGara.ID == DBNull.Value)
				{
					ValoreRitornoFunzione = false;
					errorProvider.SetError(fkIDRuoloDirigenteInGara, "Inserire un valore per ruolo.");
					errorProvider.SetIconAlignment(fkIDRuoloDirigenteInGara, ErrorIconAlignment.TopLeft);

					// Compongo le stringhe per la form dei campi obbligatori
					Campi += "Ruolo|";
					Descrizione += errorProvider.GetError(fkIDRuoloDirigenteInGara).ToString() + "|";
					Stato += "Attenzione|";

					if (!FattoFocus & controllo == null)
					{
						ControlloPerFocus = fkIDRuoloDirigenteInGara;
						FattoFocus = true;
					}
					else if (controllo != null)
					{
						return ValoreRitornoFunzione;
					}
				}
				else
				{
								string SQL = "Select Count(*) From DefaultDirigenti where IDRuoloDirigenteInGara = " + fkIDRuoloDirigenteInGara.ID.ToString() + " And ";
					if(chkCasa.Checked)
						SQL += " Casa is not null and Casa <> 0 ";
					else
						SQL += "   (Casa is null Or Casa = 0) ";
		
				IDbCommand cmd = Globals.Connection.CreateCommand();
				cmd.CommandText = SQL;
				if(General.DBToInt(cmd.ExecuteScalar()) != 0)
				{
						ValoreRitornoFunzione = false;
					errorProvider.SetError(fkIDRuoloDirigenteInGara, "Ruolo gia impostato.");
					errorProvider.SetIconAlignment(fkIDRuoloDirigenteInGara, ErrorIconAlignment.TopLeft);

					// Compongo le stringhe per la form dei campi obbligatori
					Campi += "Ruolo|";
					Descrizione += errorProvider.GetError(fkIDRuoloDirigenteInGara).ToString() + "|";
					Stato += "Attenzione|";

					if (!FattoFocus & controllo == null)
					{
						ControlloPerFocus = fkIDRuoloDirigenteInGara;
						FattoFocus = true;
					}
					else if (controllo != null)
					{
						return ValoreRitornoFunzione;
					}
				
				}
					else
				{
					errorProvider.SetError(fkIDRuoloDirigenteInGara, "");
				}
			
				}
		}

			
			if (controllo == null & Campi.Length != 0)
			{
				frmCampiObbligatori frm = new frmCampiObbligatori();
				frm.Start(Campi, Descrizione, Stato);
			}

			if (FattoFocus)
				ControlloPerFocus.Focus();

			return ValoreRitornoFunzione;
		}
		/// <summary>
		/// Controlla se i dati a video sono stati modificati
		/// </summary>
		/// <returns>true se sono stati modificati, altrimenti false</returns>
		protected bool ControllaModifica()
		{
			System.Windows.Forms.DialogResult Risposta;

			// ****************************************************************************************
			// DETAILS
			// if (!dtlXXX.ControllaModifica())
			// {
			// 	return false;
			// }
			// ****************************************************************************************


			// Controlla se qualcosa  stato cambiato ed eventualmente richiede conferma
			if (Buttons.EditInModifica)
			{
                // ******************* Per la Security ***********************
				// //Se non ho i diritti di update, non faccio nemmeno la domanda di richiesta di salvataggio e proseguo
				// if (!IGCal.Security.Application.UserPermissions[_PermissionName].Update)
                //     return true;
				// ***********************************************************

					Risposta = MessageBox.Show(base.MessageConfermaDatiModificati, base.MessageAttenzione, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

				if (Risposta == DialogResult.Yes)
					return SalvaModifica();
				else if (Risposta == DialogResult.No)
					Buttons.AggiornaEnabled = false;
				else
					return false;
			}

			if (Buttons.EditInAggiunta)
			{
				// ******************* Per la Security ***********************
				// //Se non ho i diritti di insert, non faccio nemmeno la domanda di richiesta di salvataggio e proseguo
				// if (!IGCal.Security.Application.UserPermissions[_PermissionName].Insert)
				// 	return true;
				// ***********************************************************
									
				Risposta = MessageBox.Show(base.MessageConfermaDatiModificati, base.MessageAttenzione, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

				if (Risposta == DialogResult.Yes)
					return SalvaAggiungi();
				else if (Risposta == DialogResult.No)
					Buttons.AggiornaEnabled = false;
				else
					return false;
			}

			return true;
		}

		/// <summary>
		/// Conferma le modifiche apportate all'elemento selezionato
		/// </summary>
		/// <returns>true se il record  stato aggiornato, false nel caso si siano verificati degli errori</returns>
		protected override bool SalvaModifica()
		{
			if (fkIDDirigente.ID == DBNull.Value && fkIDRuoloDirigenteInGara.ID == DBNull.Value)
			{
				MessageBox.Show(base.MessageSelezioneElementoDaModificare, base.MessageModifica, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
				return false;
			}

			// Prima di modificare l'elemento controllo che i campi obbligatori siano pieni
			if (!ControllaCampi())
				return false;

			CampiSuDB(rs.Rows[0]);

			try
			{
				DA.Update(rs);
			}
			catch (DBException ex)
			{
				frmStampaErroriDB.Start("Impossibile aggiornare l'elemento", ex);
				return false;
			}
			catch (System.Data.DBConcurrencyException ex)
			{
				frmStampaErroriDB.Start("L'elemento  stato modificato/eliminato da un altro utente.", ex);
				return false;
			}
			catch (Exception ex)
			{
				frmStampaErroriDB.Start("Impossibile aggiornare l'elemento.", ex);
				return false;
			}

			// Recupero in rs le informazioni scritte sul DB per creare nuovamente una situazione iniziale
			rs = RecuperaRecord((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

 			// Avviso gli interessati che ho modificato un record
			try
			{
				_fkControl.IDDirigente = fkIDDirigente.ID;
				_fkControl.IDRuoloDirigenteInGara = fkIDRuoloDirigenteInGara.ID;
			}
			catch
			{
				// Non faccio nulla
			}

			// Modifico il record nella lista
			ctlRicerca.Modifica((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

			Buttons.GestioneTasti(ButtonsState.SelectedRecord);

			return base.SalvaModifica();
		}

		/// <summary>
		/// Conferma l'aggiunta del nuovo record
		/// </summary>
		/// <returns>true se il record  stato aggiunto, false nel caso si siano verificati degli errori</returns>
		protected override bool SalvaAggiungi()
		{
			System.Data.DataRow row;

			// Prima di aggiungere l'elemento controllo che i campi obbligatori siano pieni
			if (!ControllaCampi())
				return false;

			if (rs == null)
				rs = RecuperaRecord((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

			// Vuoto la collection delle righe
			rs.Rows.Clear();

			// Assegno i campi alla row poi la aggiungo al dataset
			row = rs.NewRow();

			// Salvo i campi chiave
			row["IDDirigente"] = fkIDDirigente.ID;
			row["IDRuoloDirigenteInGara"] = fkIDRuoloDirigenteInGara.ID;
			row["Casa"] = General.BoolToDB(chkCasa.Checked);

			// Salvo anche gli altri campi
			CampiSuDB(row);
			
			// row["DataInserimento"] = Globals.Connection.SQLNow();
			// row["UtenteInserimento"] = IGCal.Security.Application.User;

			rs.Rows.Add(row);

			// Provo ad eseguire la modifica
			try
 			{
				DA.Update(rs);
			}
			catch (DBException ex)
			{
				frmStampaErroriDB.Start("Impossibile aggiungere l'elemento", ex);
				return false;
			}
			catch (Exception ex)
			{
				frmStampaErroriDB.Start("Impossibile aggiungere l'elemento", ex);
				return false;
			}

			// ****************************************************************************************
			// Devo recuperare il record appena inserito: necessario per recuperare il valore di un eventuale campo autonumerante non CHIAVE
			// rs = RecuperaRecord((int)fkIDDirigente.ID, (int)numIDRuoloDirigenteInGara.Value);
			// if (rs.Rows.Count != 0)
			// {
			// 	numXXX.Value = rs.Rows[0]["XXX"];
			// }
			// ****************************************************************************************

			ctlRicerca.Aggiungi((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

			// Disabilito i campi che compongono la chiave
			fkIDDirigente.Enabled = false;
			fkIDRuoloDirigenteInGara.Enabled = false;
			chkCasa.Enabled = false;

			// Avviso gli interessati che ho modificato un record
			try
			{
				_fkControl.IDDirigente = fkIDDirigente.ID;
				_fkControl.IDRuoloDirigenteInGara = fkIDRuoloDirigenteInGara.ID;
			}
			catch
			{
				// Non faccio nulla
			}

			bool result = base.SalvaAggiungi();

			// In base alla AfterInsertAction decido come procedere
			if (base._AfterInsertAction == AfterInsertAction.Edit || (base._AfterInsertAction == AfterInsertAction.Option && Globals.AfterInsertAction == AfterInsertAction.Edit))
			{
				Buttons.GestioneTasti(ButtonsState.SelectedRecord);

				// ****************************************************************************************
				// DETAILS
				// Eseguo il refresh del dtl
				// dtlXXX.Refresh(Campo.Value);
				//
				// tabDettaglio.Enabled = true;         // Anche per altri eventuali TAB di dettagli
				// ****************************************************************************************
			}
			else if (base._AfterInsertAction == AfterInsertAction.New || (base._AfterInsertAction == AfterInsertAction.Option && Globals.AfterInsertAction == AfterInsertAction.New))
			{
				// ****************************************************************************************
				// DETAILS
				// SSTab.SelectedTab = tabGenerale;
				//
				// Eseguo il refresh del dtl
				// dtlXXX.Refresh(DBNull.Value);
				//
				// tabDettaglio.Enabled = false;			// Anche per altri eventuali TAB di dettagli
				// ****************************************************************************************

				PulisciCampi();

				Buttons.GestioneTasti(ButtonsKeyPressed.New);
			}

			return result;
		}

		#endregion

		#region Gestione degli eventi dei controlli interni alla form

		/// <summary>
		/// Richiama una funzione in base al tasto premuto
		/// </summary>
		/// <param name="buttonsKeyPressed">Tasto premuto</param>
		protected void Buttons_OnClick(ButtonsKeyPressed buttonsKeyPressed)
		{
			switch (buttonsKeyPressed)
			{
				case ButtonsKeyPressed.New:
					btnNuovo();
					break;
				case ButtonsKeyPressed.Copy:
					btnCopia();
					break;
				case ButtonsKeyPressed.Update:
					if (Buttons.EditInAggiunta)
						btnAggiungi();
					else if (Buttons.EditInModifica)
						btnModifica();
					break;
				case ButtonsKeyPressed.Delete:
					btnElimina();
					break;
				case ButtonsKeyPressed.Exit:
					btnEsci();
					break;
			}
		}

		/// <summary>
		/// Predispone il form per l'inserimento di un nuovo record
		/// </summary>
		protected void btnNuovo()
		{
			if (!ControllaModifica())
				return;

			// ****************************************************************************************
			// DETAILS
			// SSTab.SelectedTab = tabGenerale;
			//
			// Eseguo il refresh del dtl
			// dtlXXX.Refresh(DBNull.Value);
			//
			// tabDettaglio.Enabled = false;			// Anche per altri eventuali TAB di dettagli
			// ****************************************************************************************

			PulisciCampi();

			if (rs != null)
				rs.Rows.Clear();  // Vuoto la collection delle righe

			// Abilito i campi che compongono la chiave
			fkIDDirigente.Enabled = true;
			fkIDRuoloDirigenteInGara.Enabled = true;
			chkCasa.Enabled = true;
			fkIDDirigente.Focus();
			Buttons.GestioneTasti(ButtonsKeyPressed.New);
		}

		/// <summary>
		/// Predispone il form per l'inserimento di un nuovo record
		/// </summary>
		protected void btnCopia()
		{
			if (!ControllaModifica())
				return;

			// ****************************************************************************************
			// DETAILS
			// SSTab.SelectedTab = tabGenerale;
			//
			// Eseguo il refresh del dtl
			// dtlXXX.Refresh(DBNull.Value);
			//
			// tabDettaglio.Enabled = false;			// Anche per altri eventuali TAB di dettagli
			// ****************************************************************************************

			if (rs != null)
				rs.Rows.Clear(); // Vuoto la collection delle righe

			// Pulisco i campi chiave
			fkIDDirigente.ID = DBNull.Value;
			fkIDRuoloDirigenteInGara.ID = DBNull.Value;
			chkCasa.CheckState = CheckState.Unchecked;
 

			// Abilito i campi che compongono la chiave
			fkIDDirigente.Enabled = true;
			fkIDRuoloDirigenteInGara.Enabled = true;
			chkCasa.Enabled = true;
			fkIDDirigente.Focus();
			Buttons.GestioneTasti(ButtonsKeyPressed.Copy);
		}

		/// <summary>
		/// Conferma le modifiche apportate al record
		/// </summary>
		protected void btnModifica()
		{
 			SalvaModifica();
		}

		/// <summary>
		/// Conferma l'inserimento del nuovo record
		/// </summary>
		protected void btnAggiungi()
		{
			if (SalvaAggiungi())
			{
				// ****************************************************************************************
				// DETAILS
				// Eseguo il refresh del dtl
				// dtlXXX.Refresh(Campo.Value);
				//
				// tabDettaglio.Enabled = true;         // Anche per altri eventuali TAB di dettagli
				// ****************************************************************************************
			}
		}

		/// <summary>
		/// Elimina il record selezionato
		/// </summary>
		protected void btnElimina()
		{
			if (fkIDDirigente.ID == DBNull.Value && fkIDRuoloDirigenteInGara.ID == DBNull.Value)
			{
				MessageBox.Show(base.MessageSelezioneElemento, base.MessageElimina, MessageBoxButtons.OK, MessageBoxIcon.Warning);
				return;
			}

			// Chiedo conferma prima di eliminare
			if (MessageBox.Show(base.ConfermaEliminazione, base.MessageElimina, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
				return;

			if (rs.Rows.Count == 0)
			{
				MessageBox.Show(base.EliminatoDaAltroUtente, base.MessageElimina, MessageBoxButtons.OK, MessageBoxIcon.Stop);
				return;
			}

			// Eseguo la cancellazione sul dataset
			rs.Rows[0].Delete();

			// Porto la modifica sui dati reali
			try
			{
				DA.Update(rs);
			}
			catch (DBException ex)
			{
				// Ricarico rs
				rs = RecuperaRecord((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

				frmStampaErroriDB.Start("Impossibile eliminare l'elemento.", ex);
				return;
			}
			catch (System.Exception ex)
			{
				// Ricarico rs
				rs = RecuperaRecord((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

				frmStampaErroriDB.Start("L'elemento  stato eliminato da un altro utente.", ex);
				return;
			}

			// Controllo che l'ID di _fkControl non sia quello che ho cancellato
			try
			{
				if (_fkControl.IDDirigente.ToString().Trim() == fkIDDirigente.ID.ToString().Trim() && _fkControl.IDRuoloDirigenteInGara.ToString().Trim() == fkIDRuoloDirigenteInGara.ID.ToString().Trim())
				{
					_fkControl.IDDirigente = DBNull.Value;
					_fkControl.IDRuoloDirigenteInGara = DBNull.Value;
					_fkControl.Casa = DBNull.Value;
				
				}
			}
			catch
			{
				// Non faccio nulla
			}
			// Elimino il record dalla lista
			ctlRicerca.Elimina((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, chkCasa.Checked);

			// Mi comporto come se avessi appena premuto nuovo
			btnNuovo();
		}

		/// <summary>
		/// Esce dal form
		/// </summary>
		protected void btnEsci()
		{
			if (rs != null)
				rs.Dispose();

			this.Close();		
		}

		/// <summary>
		/// Funzione richiamata al momento della selezione di un elemento nella lista
		/// </summary>
		/// <param name="sender">Oggetto inviante l'evento</param>
		/// <param name="e">Argomenti standard dell'evento</param>
 		protected void ctlRicerca_OnItemClick(object sender, EventArgs e)
		{
			object _IDDirigente = ctlRicerca.IDDirigente;
			object _IDRuoloDirigenteInGara = ctlRicerca.IDRuoloDirigenteInGara;
			object _Casa = ctlRicerca.Casa;

			if (!ControllaModifica())
			{
				if (!Buttons.EditInAggiunta)
					ctlRicerca.ImpostaElementoSelezionato((int)fkIDDirigente.ID, (int)fkIDRuoloDirigenteInGara.ID, General.DBToBool(_Casa));
		
				return;
			}

			ctlRicerca.ImpostaElementoSelezionato((int)_IDDirigente, (int)_IDRuoloDirigenteInGara, General.DBToBool(_Casa));

			RecordAVideo((int)_IDDirigente, (int)_IDRuoloDirigenteInGara, General.DBToBool(_Casa));
		}

		/// <summary>
		/// Funzione che si occupa di riportare il contenuto del record individuato dai parametri a video
		/// </summary>
		private void RecordAVideo(int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			rs = RecuperaRecord(IDDirigente, IDRuoloDirigenteInGara, Casa);

			if (rs.Rows.Count == 0)
			{
				MessageBox.Show(base.EliminatoDaAltroUtente, base.MessageAttenzione, MessageBoxButtons.OK, MessageBoxIcon.Warning);

				// Non avendo trovato il record nel DB mi comporto come se avessi premuto Nuovo
				btnNuovo();

				return;
			}

			// Visualizzo il record
			CampiAVideo(rs.Rows[0]);
			// Disabilito i campi che compongono l'ID
			// Disabilito i campi che compongono la chiave
			fkIDDirigente.Enabled = false;
			fkIDRuoloDirigenteInGara.Enabled = false;
			chkCasa.Enabled = false;

			Buttons.GestioneTasti(ButtonsState.SelectedRecord);

			// ****************************************************************************************
 			// DETAILS
			// Eseguo il refresh del dtl
 			//
			// tabDettaglio.Enabled = true;						// Anche per altri eventuali TAB di dettagli
			//
			// switch (SSTab.SelectedIndex)
			// {
			// 	case 1:								// Anche per altri eventuali TAB di dettagli
			//		dtlXXX.Refresh(Campo.Value);
			// 		break;
			// }
			// ****************************************************************************************
		}

		/// <summary>
		/// Funzione eseguita alla fine di una ricerca effettuata dal ctlRicerca
		/// </summary>
		/// <param name="sender">Oggetto inviante l'evento</param>
		/// <param name="e">Argomenti standard dell'evento</param>
		protected void ctlRicerca_OnFineRicerca(object sender, System.EventArgs e)
		{
			btnNuovo();
		}

		/// <summary>
		/// Funzione chiamata sul Leave dei controlli
		/// </summary>
		/// <param name="sender">Oggetto inviante l'evento</param>
		/// <param name="e">Argomenti standard dell'evento</param>
		protected virtual void Controllo_OnLeave(object sender, System.EventArgs e)
		{
			// Si occupa di gestire il controllo di obbligatoriet dei campi presi singolarmente
			ControllaCampi((System.Windows.Forms.Control)sender);		
		}

		/// <summary>
		/// Funzione eseguita alla chiusura del form
		/// </summary>
		/// <param name="sender">Oggetto inviante l'evento</param>
		/// <param name="e">Argomenti standard dell'evento</param>
		protected override void Form_OnClosing(object sender, System.ComponentModel.CancelEventArgs e)
		{
			if (!ControllaModifica())
			{
				e.Cancel = true;
				return;
			}

			base.Form_OnClosing(sender,e);

			// ****************************************************************************************
			// DETAILS
			// dtlXXX.Terminate();
			// ****************************************************************************************
		}

		// ****************************************************************************************
		// DETAILS
		// protected void OnSelectedTABChanged(object sender, System.EventArgs e)
		// {
		// 	switch (SSTab.SelectedIndex)		// 	{
		// 		case 1:
		// 			dtlXXX.Refresh(Campo.Value);
		// 			break;
		//	}
		// }
		// '****************************************************************************************

		#endregion		


		#region Legami delle procedure evento agli eventi dei controlli

		private void LegaProcedureAEventi()
		{ 			
			// Per gli altri controlli:
			// 	- legame di TextChanged ad AbilitaModifica per tutti i controlli la cui modifica deve
			//	  avere un effetto sui pulsanti Aggiungi e/o Modifica.
			//	- legame di Leave a Controllo_OnLeave per tutti i controlli il cui contenuto deve essere
			//	  obbligatorio. 
			// TextChanged --> AbilitaModifica
			this.fkIDDirigente.TextChanged += new System.EventHandler(AbilitaModifica);
			this.fkIDRuoloDirigenteInGara.TextChanged += new System.EventHandler(AbilitaModifica);
			this.chkCasa.Click += new System.EventHandler(AbilitaModifica);

			// Leave --> Controllo_OnLeave
			this.fkIDDirigente.Leave += new System.EventHandler(this.Controllo_OnLeave);
			this.fkIDRuoloDirigenteInGara.Leave += new System.EventHandler(this.Controllo_OnLeave);

			// Per la pulsantiera ed i pulsanti
			this.Buttons.ButtonClick += new ButtonClickEventHandler(Buttons_OnClick);

			// Per il ctlRicerca
			this.ctlRicerca.FineRicerca += new System.EventHandler(this.ctlRicerca_OnFineRicerca);
			this.ctlRicerca.ItemClick += new EventHandler(this.ctlRicerca_OnItemClick);

			// Per il Form
			this.Closing += new System.ComponentModel.CancelEventHandler(this.Form_OnClosing);

			// ****************************************************************************************
			// DETAILS
			// Per l'SSTab
			// this.SSTab.SelectedIndexChanged += new System.EventHandler(this.OnSelectedTABChanged);
			// ****************************************************************************************
		}
		#endregion

	}
}


